home *** CD-ROM | disk | FTP | other *** search
/ Aminet 30 / Aminet 30 (1999)(Schatztruhe)[!][Apr 1999].iso / Aminet / dev / lang / SmallEiffel.lha / SmallEiffel / lib_se / short_print.e < prev    next >
Text File  |  1998-12-22  |  7KB  |  370 lines
  1. --          This file is part of SmallEiffel The GNU Eiffel Compiler.
  2. --          Copyright (C) 1994-98 LORIA - UHP - CRIN - INRIA - FRANCE
  3. --            Dominique COLNET and Suzanne COLLIN - colnet@loria.fr 
  4. --                       http://www.loria.fr/SmallEiffel
  5. -- SmallEiffel is  free  software;  you can  redistribute it and/or modify it 
  6. -- under the terms of the GNU General Public License as published by the Free
  7. -- Software  Foundation;  either  version  2, or (at your option)  any  later 
  8. -- version. SmallEiffel is distributed in the hope that it will be useful,but
  9. -- WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  10. -- or  FITNESS FOR A PARTICULAR PURPOSE.   See the GNU General Public License 
  11. -- for  more  details.  You  should  have  received a copy of the GNU General 
  12. -- Public  License  along  with  SmallEiffel;  see the file COPYING.  If not,
  13. -- write to the  Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  14. -- Boston, MA 02111-1307, USA.
  15. --
  16. class SHORT_PRINT
  17.    --
  18.    -- Driver for the `short' command.
  19.    --
  20.  
  21. inherit GLOBALS;
  22.  
  23. creation make
  24.  
  25. feature {NONE}
  26.  
  27.    format_directory: STRING;
  28.      -- For the output style.
  29.  
  30.    base_class: BASE_CLASS;
  31.      -- The one printed.
  32.  
  33.    run_class: RUN_CLASS;
  34.      -- The one printed.
  35.  
  36. feature {NONE}
  37.  
  38.    make is
  39.       do
  40.       end;
  41.    
  42. feature {SHORT}
  43.  
  44.    start(format: STRING; bc: BASE_CLASS; rc: RUN_CLASS) is
  45.       local
  46.      hc2: COMMENT;
  47.      fgl: FORMAL_GENERIC_LIST;
  48.       do
  49.      base_class := bc;
  50.      run_class := rc;
  51.      format_directory := system_tools.format_directory(format);
  52.      -- Start output :
  53.      hook("hook000");
  54.      if bc.is_expanded then
  55.         hook_or("hook010","expanded class interface ");
  56.      elseif bc.is_deferred then
  57.         hook_or("hook011","deferred class interface ");
  58.      else
  59.         hook_or("hook012","class interface ");
  60.      end;
  61.      hook("hook013");
  62.      a_class_name(bc.name);
  63.      fgl := bc.formal_generic_list;
  64.      if fgl /= Void then
  65.         fgl.short;
  66.      end;
  67.      hook_or("hook014","%N");
  68.      hc2 := bc.heading_comment2;
  69.      if hc2 /= Void then
  70.         hook("hook015");
  71.         hc2.short("hook016","   -- ","hook017","%N");
  72.         hook("hook018");
  73.      else
  74.         hook("hook019");
  75.      end;
  76.       end;
  77.  
  78.    finish is
  79.       local
  80.      fgl: FORMAL_GENERIC_LIST;
  81.      ci: CLASS_INVARIANT;
  82.       do
  83.      ci := run_class.class_invariant;
  84.      if ci = Void then
  85.         hook("hook800");
  86.      else
  87.         ci.short(base_class);
  88.      end;
  89.      hook("hook900");
  90.      if base_class.is_expanded then
  91.         hook_or("hook901","end of expanded ");
  92.      elseif base_class.is_deferred then
  93.         hook_or("hook902","end of deferred ");
  94.      else
  95.         hook_or("hook903","end of ");
  96.      end;
  97.      hook("hook904");
  98.      a_class_name(base_class.name);
  99.      fgl := base_class.formal_generic_list;
  100.      if fgl /= Void then
  101.         fgl.short;
  102.      end;
  103.      hook_or("hook905","%N");
  104.      hook("hook999");
  105.       end;
  106.  
  107. feature
  108.  
  109.    hook_or(h, str: STRING) is
  110.       do
  111.      if hook_exists(h) then
  112.         from
  113.            tmp_hook.read_character;
  114.         until
  115.            tmp_hook.end_of_input
  116.         loop
  117.            std_output.put_character(tmp_hook.last_character);
  118.            tmp_hook.read_character;
  119.         end;
  120.         tmp_hook.disconnect;
  121.      else
  122.         std_output.put_string(str);
  123.      end;
  124.       end;
  125.  
  126.    hook_and(h,name : STRING) is
  127.      -- write name and hook if hook exists
  128.       do
  129.      if hook_exists(h) then
  130.         tmp_string.copy(name);
  131.         tmp_string.to_lower;
  132.         std_output.put_string(tmp_string);
  133.         from
  134.            tmp_hook.read_character;
  135.         until
  136.            tmp_hook.end_of_input
  137.         loop
  138.            std_output.put_character(tmp_hook.last_character);
  139.            tmp_hook.read_character;
  140.         end;
  141.         tmp_hook.disconnect;
  142.      end;
  143.       end;
  144.  
  145.    hook(h: STRING) is
  146.       do
  147.      if hook_exists(h) then
  148.         from
  149.            tmp_hook.read_character;
  150.         until
  151.            tmp_hook.end_of_input
  152.         loop
  153.            std_output.put_character(tmp_hook.last_character);
  154.            tmp_hook.read_character;
  155.         end;
  156.         tmp_hook.disconnect;
  157.      end;
  158.       end;
  159.  
  160.    a_class_name(name: CLASS_NAME) is
  161.       local
  162.      i: INTEGER;
  163.      c: CHARACTER;
  164.      str: STRING;
  165.       do
  166.      hook("Bcn");
  167.      hook_and("Mcn",name.to_string);
  168.      from
  169.         str := name.to_string;
  170.         i := 1;
  171.      until
  172.         i > str.count
  173.      loop
  174.         c := str.item(i);
  175.         if c = '_' then
  176.            hook_or("Ucn","_");
  177.         else
  178.            std_output.put_character(c);
  179.         end;
  180.         i := i + 1;
  181.      end;
  182.      hook("Acn");
  183.       end;
  184.  
  185.    a_feature(fn: FEATURE_NAME) is
  186.      -- Where `fn' is really the final name to print.
  187.       local
  188.      rf: RUN_FEATURE;
  189.       do
  190.      rf := run_class.get_feature(fn);
  191.      a_run_feature(rf);
  192.       end;
  193.  
  194.    a_run_feature(rf: RUN_FEATURE) is
  195.       local
  196.      args: FORMAL_ARG_LIST;
  197.      rt: TYPE;
  198.      hc: COMMENT;
  199.      rr: RUN_REQUIRE;
  200.      ea: E_ENSURE;
  201.       do
  202.      hook_or("hook300","   ");
  203.      rf.name.short;
  204.      args := rf.arguments;
  205.      if args = Void then
  206.         hook_or("hook301","");
  207.      else
  208.         args.short;
  209.      end;
  210.      rt := rf.result_type;
  211.      if rt = Void then
  212.         hook_or("hook307","%N");
  213.      else
  214.         hook_or("hook308",": ");
  215.         rt.short;
  216.         hook_or("hook309","%N");
  217.      end;
  218.      hc := rf.base_feature.header_comment;
  219.      if hc /= Void then
  220.         hook("hook310");
  221.         hc.short("hook311","      -- ","hook312","%N");
  222.         hook("hook313");
  223.      else
  224.         hook("hook314");
  225.      end;
  226.      rr := rf.require_assertion;
  227.      if rr = Void then
  228.         hook("hook400");
  229.      else
  230.         rr.short;
  231.      end;
  232.      ea := rf.ensure_assertion;
  233.      if ea = Void then
  234.         hook_or("hook500","");
  235.      else
  236.         ea.short;
  237.      end;
  238.      hook_or("hook599","");
  239.       end;
  240.  
  241.    a_integer(value: INTEGER) is
  242.       local
  243.      s: STRING;
  244.      c: CHARACTER;
  245.      i: INTEGER;
  246.       do
  247.      s := "";
  248.      s.clear;
  249.      value.append_in(s);
  250.      from
  251.         i := 1;
  252.      until
  253.         i > s.count
  254.      loop
  255.         c := s.item(i);
  256.         std_output.put_character(c);
  257.         i := i + 1;
  258.      end;
  259.       end;
  260.  
  261.    a_character(c: CHARACTER) is
  262.       do
  263.      std_output.put_character(c);
  264.       end;
  265.  
  266.    a_dot is
  267.       do
  268.      hook_or("dot",fz_dot);
  269.       end;
  270.  
  271. feature {CALL_PREFIX}
  272.  
  273.    a_prefix_name(pn: PREFIX_NAME) is
  274.      -- Used in an expression.
  275.       local
  276.      i: INTEGER;
  277.      c: CHARACTER;
  278.      str: STRING;
  279.       do
  280.      from
  281.         str := pn.to_string;
  282.         i := 1;
  283.      until
  284.         i > str.count
  285.      loop
  286.         c := str.item(i);
  287.         if c = '_' then
  288.            hook_or("Usfn","_");
  289.         else
  290.            std_output.put_character(c);
  291.         end;
  292.         i := i + 1;
  293.      end;
  294.      a_character(' ');
  295.       end;
  296.       
  297. feature {CALL_INFIX,INFIX_NAME}
  298.  
  299.    a_infix_name(h1,r1,h2,r2: STRING; in: INFIX_NAME) is
  300.       local
  301.      i: INTEGER;
  302.      str: STRING;
  303.       do
  304.      hook_or(h1,r1);
  305.      str := in.to_string;
  306.      if us_backslash_backslash = str then
  307.         hook_or("rem",us_backslash_backslash);
  308.      else
  309.         from
  310.            i := 1;
  311.         until
  312.            i > str.count
  313.         loop
  314.            std_output.put_character(str.item(i));
  315.            i := i + 1;
  316.         end;
  317.      end;
  318.      hook_or(h2,r2);
  319.       end;
  320.       
  321. feature {BASE_TYPE_CONSTANT}
  322.  
  323.    a_base_type_constant(str: STRING) is
  324.       local
  325.      i: INTEGER;
  326.      c: CHARACTER;
  327.       do
  328.      from
  329.         i := 1;
  330.      until
  331.         i > str.count
  332.      loop
  333.         c := str.item(i);
  334.         if c = '.' then
  335.            hook_or("dot",".");
  336.         else
  337.            std_output.put_character(c);
  338.         end;
  339.         i := i + 1;
  340.      end;
  341.       end;
  342.  
  343. feature {NONE}
  344.  
  345.    hook_exists(h: STRING): BOOLEAN is
  346.       do
  347.      tmp_hook_path.copy(format_directory);
  348.      tmp_hook_path.append(h);
  349.      tmp_hook.connect_to(tmp_hook_path);
  350.      Result := tmp_hook.is_connected;
  351.       end;
  352.  
  353.    tmp_hook: STD_FILE_READ is
  354.       once
  355.      !!Result.make;
  356.       end;
  357.  
  358.    tmp_hook_path: STRING is
  359.       once
  360.      !!Result.make(80);
  361.       end;
  362.  
  363.    tmp_string: STRING is
  364.       once
  365.      !!Result.make(16);
  366.       end;
  367.  
  368. end -- SHORT_PRINT
  369.  
  370.